import numpy as np # numeric processing
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
from sklearn.feature_extraction import DictVectorizer
from sklearn.impute import SimpleImputer
from sklearn.model_selection import train_test_split
from IPython.display import HTML
from sklearn.pipeline import Pipeline
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import StratifiedShuffleSplit
from sklearn.model_selection import train_test_split
from sklearn.decomposition import PCA
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import f1_score, classification_report
from sklearn.tree import DecisionTreeClassifier
from sklearn.preprocessing import StandardScaler
from functools import *
import ydata_profiling
import matplotlib.pyplot as plt
from sklearn.pipeline import Pipeline

#!pip install turicreate -q

!chmod a+x get_data.sh
!./get_data.sh

Downloading dataset from kaggle
This may take a few minutes...
Link: https://www.kaggle.com/mansoordaku/ckdisease
Attempt 1 of 5...
Warning: Looks like you're using an outdated API Version, please consider updating (server 1.7.4.2 / client 1.6.17)
Dataset URL: https://www.kaggle.com/datasets/mansoordaku/ckdisease
License(s): unknown
Downloading ckdisease.zip to /home/stormbird/Desktop/chronic-kidney-disease-kaggle
  0%|                                               | 0.00/9.51k [00:00<?, ?B/s]
100%|██████████████████████████████████████| 9.51k/9.51k [00:00<00:00, 10.8MB/s]
Dataset downloaded successfully.
Archive:  ckdisease.zip
  inflating: kidney_disease.csv      
Dataset downloaded successfully and moved to data/input folder
kidney_disease.csv

# load the dataset with pandas read_csv function
df = pd.read_csv('data/input/kidney_disease.csv', index_col="id")

# give the dtypes of the columns if the data was squeeky clean
dtypes = {
    'id' : np.int32,
    'age' : np.int32,
    'bp' : np.float32,
    'sg' : object, # category
    'al' : object, # category # mistake
    'su' : object, #category  # mistake
    'rbc' : object, # category
    'pc' : object, # category
    'pcc' : object, # category
    'ba' : object, # category
    'bgr' : np.float32,
    'bu' : np.int32,
    'sc' : np.float32,
    'sod': np.int32,
    'pot' : np.float32,
    'hemo' : np.float32,
    'pcv' : np.int32,
    'wc' : np.int32,
    'rc' : np.int32,
    'htn' : object,
    'dm' : object,
    'cad' : object,
    'appet': object,
    'pe' : object,
    'ane' : object,
    'class': object}

# another way of reading in the datasets especially very big files like 1GB big
# df2 = dd.read_csv('../input/kidney_disease.csv', dtype=dtypes)
# id                400 non-null int64
# age               391 non-null float64
# bp                388 non-null float64
# sg                353 non-null float64
# al                354 non-null float64
# su                351 non-null float64
# rbc               248 non-null object
# pc                335 non-null object
# pcc               396 non-null object
# ba                396 non-null object
# bgr               356 non-null float64
# bu                381 non-null float64
# sc                383 non-null float64
# sod               313 non-null float64
# pot               312 non-null float64
# hemo              348 non-null float64
# pcv               330 non-null object
# wc                295 non-null object
# rc                270 non-null object
# htn               398 non-null object
# dm                398 non-null object
# cad               398 non-null object
# appet             399 non-null object
# pe                399 non-null object
# ane               399 non-null object
# classification    400 non-null object

# see the first couple of observations and transpose 10 observations
# think of it as rolling over your dataset
df.head(10).transpose()

# see the column names
df.columns

Index(['age', 'bp', 'sg', 'al', 'su', 'rbc', 'pc', 'pcc', 'ba', 'bgr', 'bu',
       'sc', 'sod', 'pot', 'hemo', 'pcv', 'wc', 'rc', 'htn', 'dm', 'cad',
       'appet', 'pe', 'ane', 'classification'],
      dtype='object')

# see a concise summary of the dataset
df.info()

<class 'pandas.core.frame.DataFrame'>
Index: 400 entries, 0 to 399
Data columns (total 25 columns):
 #   Column          Non-Null Count  Dtype  
---  ------          --------------  -----  
 0   age             391 non-null    float64
 1   bp              388 non-null    float64
 2   sg              353 non-null    float64
 3   al              354 non-null    float64
 4   su              351 non-null    float64
 5   rbc             248 non-null    object 
 6   pc              335 non-null    object 
 7   pcc             396 non-null    object 
 8   ba              396 non-null    object 
 9   bgr             356 non-null    float64
 10  bu              381 non-null    float64
 11  sc              383 non-null    float64
 12  sod             313 non-null    float64
 13  pot             312 non-null    float64
 14  hemo            348 non-null    float64
 15  pcv             330 non-null    object 
 16  wc              295 non-null    object 
 17  rc              270 non-null    object 
 18  htn             398 non-null    object 
 19  dm              398 non-null    object 
 20  cad             398 non-null    object 
 21  appet           399 non-null    object 
 22  pe              399 non-null    object 
 23  ane             399 non-null    object 
 24  classification  400 non-null    object 
dtypes: float64(11), object(14)
memory usage: 81.2+ KB

# display summary statistics of each column
# this helps me confirm my assertion on missing data
df.describe(include="all").transpose()

# Looking at variables interractively

profile = ydata_profiling.ProfileReport(df)

profile

Summarize dataset:   0%|          | 0/5 [00:00<?, ?it/s]

Generate report structure:   0%|          | 0/1 [00:00<?, ?it/s]

Render HTML:   0%|          | 0/1 [00:00<?, ?it/s]

# looking for the number of missing observations
# In the code below a boolean is being tried on each observation asking if the observation is missing or not
# then add all instances of NaN(Not a number)
missing_values = df.isnull().sum()

# calculating the percentage of missing values in the dataframe
# simply taking the sum of the values we got above dividing by the no of observations in the df
# you could use len(df) instead df.index.size
missing_count_pct = ((missing_values / df.index.size) * 100)

# see how many observations are missing
print(missing_count_pct)

age                2.25
bp                 3.00
sg                11.75
al                11.50
su                12.25
rbc               38.00
pc                16.25
pcc                1.00
ba                 1.00
bgr               11.00
bu                 4.75
sc                 4.25
sod               21.75
pot               22.00
hemo              13.00
pcv               17.50
wc                26.25
rc                32.50
htn                0.50
dm                 0.50
cad                0.50
appet              0.25
pe                 0.25
ane                0.25
classification     0.00
dtype: float64

# take the missing count percentage and use boolean mask to filter out columns
# whose observation threshold is greater than 25 percent
# 25 is a random number chosen based how much missing data is in the dataset
# 25-50 is normally a red flag since most data is missing
columns_to_drop = missing_count_pct[missing_count_pct > 25].index

# remove columns that meet that threshold and save result in column df_dropped
df_dropped = df.drop(columns_to_drop, axis=1)

# number of columns remaining after filtering
df.columns.size - df_dropped.columns.size

# only three columns are lost

3

# look at the code book on kaggle and write which columns could be useful here

# checking the types of the column to figure out the best next steps of conversion of data types
df.dtypes

age               float64
bp                float64
sg                float64
al                float64
su                float64
rbc                object
pc                 object
pcc                object
ba                 object
bgr               float64
bu                float64
sc                float64
sod               float64
pot               float64
hemo              float64
pcv                object
wc                 object
rc                 object
htn                object
dm                 object
cad                object
appet              object
pe                 object
ane                object
classification     object
dtype: object

# fix the columns to be of the categorical type
# if the value is missing replace the NA with the word miss
constant_imputer = SimpleImputer(strategy="constant", fill_value = "miss")

# apply it to categorical columns
df[["rbc"]] = constant_imputer.fit_transform(df[["rbc"]])
df[["pcc"]] = constant_imputer.fit_transform(df[["pcc"]])

# converting the types to be categorical
# Go ahead and use a function here
df['rbc'] = df['rbc'].astype("category")
df['pc'] = df['pc'].astype("category")
df["pcc"] = df['pcc'].astype("category")
df['ba'] = df['ba'].astype("category")
df['appet'] = df['appet'].astype("category")
df['pe'] = df['pe'].astype("category")
df['ane'] = df['ane'].astype("category")
df['classification'] = df['classification'].astype("category")
df['htn'] = df['htn'].astype("category")
df['dm'] = df['dm'].astype("category")
df['cad'] = df['cad'].astype("category")


# confirm the dtypes now
df.dtypes

age                float64
bp                 float64
sg                 float64
al                 float64
su                 float64
rbc               category
pc                category
pcc               category
ba                category
bgr                float64
bu                 float64
sc                 float64
sod                float64
pot                float64
hemo               float64
pcv                 object
wc                  object
rc                  object
htn               category
dm                category
cad               category
appet             category
pe                category
ane               category
classification    category
dtype: object

# seeing the columns in list form thinking mode
df.columns

Index(['age', 'bp', 'sg', 'al', 'su', 'rbc', 'pc', 'pcc', 'ba', 'bgr', 'bu',
       'sc', 'sod', 'pot', 'hemo', 'pcv', 'wc', 'rc', 'htn', 'dm', 'cad',
       'appet', 'pe', 'ane', 'classification'],
      dtype='object')

# make a copy of the whole dataset
df_copy = df.copy()

# remove the target column for the other uses in the next steps
#df = df.drop("classification", axis = 1)

# using a boolean to figure out which columns are of type object and numeric to do other preprocessing
# in the workflow
object_columns = df.dtypes == "object"
numeric_columns = df.dtypes == "float64"
category_columns = df.dtypes == "category"

# use regular expressions to fix it and this is supposed to be one of the first steps after df.dtypes command. If it's categorical
# you can replace it with anything you want here I use -999 to replace the data entries the tab character to flag them as outliers.
# I change the dtypes so to 32 bit to save memory

df['pcv'] = df['pcv'].replace("\t?",-999).fillna(0).astype("int32") # use  str.replace on column to something meaningful
df['wc'] = df['wc'].replace("\t?", -999).fillna(0).astype("int32") # use  str.replace on column to something meaningful
df['rc'] = df['rc'].replace("\t?", -999).fillna(0).astype("float32") # use  str.replace on column to something meaningful

# exploring another imputation strategy that uses the median
# mean_imputer = SimpleImputer(strategy="median")
# df["pcv"] = mean_imputer.fit_transform(df["pcv"])
# df["wc"] = mean_imputer.fit_transform(df["wc"])
# df["rc"] = mean_imputer.fit_transform(df["rc"])

# write code to extract columns of the type object and numeric
# Make a boolean mask for categorical columns
cat_mask_obj = (df.dtypes == "object") | (df.dtypes == "category")

# Get list of categorical column names
cat_mask_object = df.columns[cat_mask_obj].tolist()

# now for numerical columns
# anything that was parsed as float64 is numeric: make a boolean mask for that
cat_mask_numeric = (df.dtypes == "float64")
cat_mask_numeric = df.columns[cat_mask_numeric].tolist()

# see the result in a combined list: to the left categorical and the right we have numeric columns
print(cat_mask_object, "\n", cat_mask_numeric)

['rbc', 'pc', 'pcc', 'ba', 'htn', 'dm', 'cad', 'appet', 'pe', 'ane', 'classification'] 
 ['age', 'bp', 'sg', 'al', 'su', 'bgr', 'bu', 'sc', 'sod', 'pot', 'hemo']

# convert all instances of the float 64 to float 32 to speed up computation in the subsequent steps
# remove all the missing values and make sure that they are all numeric
numeric_columns_float32 = df[cat_mask_numeric].astype("float32").fillna(0)

#it's worked
numeric_columns_float32.dtypes

age     float32
bp      float32
sg      float32
al      float32
su      float32
bgr     float32
bu      float32
sc      float32
sod     float32
pot     float32
hemo    float32
dtype: object

# Task: split the category columns and object columns to the right type
# you can import the dataset to have the right types too upon import
# you can do this the next time you have time to continue working on this add it as comment though

# it makes sense that they are some individuals who were not sampled therefore filling the whole dataset with NAs makes sense
# these two columns have data entry problems
# use regular expressions to fix it and this is supposed to be one of the first steps after df.dtypes command. If it's categorical
# you can replace it with anything you want
#df['pcv'] = df['pcv'].fillna(0, inplace = True)
#df['rc'] = df['rc'].fillna(0, inplace = True)
#df['wc'] = df['wc'].fillna(0, inplace = True)

# finding the number of null or NA values in the columns
pd.isnull(df).sum()

age                9
bp                12
sg                47
al                46
su                49
rbc                0
pc                65
pcc                0
ba                 4
bgr               44
bu                19
sc                17
sod               87
pot               88
hemo              52
pcv                0
wc                 0
rc                 0
htn                2
dm                 2
cad                2
appet              1
pe                 1
ane                1
classification     0
dtype: int64

# checking the dtypes once more
df.dtypes

age                float64
bp                 float64
sg                 float64
al                 float64
su                 float64
rbc               category
pc                category
pcc               category
ba                category
bgr                float64
bu                 float64
sc                 float64
sod                float64
pot                float64
hemo               float64
pcv                  int32
wc                   int32
rc                 float32
htn               category
dm                category
cad               category
appet             category
pe                category
ane               category
classification    category
dtype: object

# concatentate the numeric columns with the category columns to build the full dataset and then X and Y
# remove
df[cat_mask_object] = constant_imputer.fit_transform(df[cat_mask_object])

# check for missing values
print(df[cat_mask_object].isnull().sum())
print("*" * 100)
print(numeric_columns_float32.isnull().sum())

rbc               0
pc                0
pcc               0
ba                0
htn               0
dm                0
cad               0
appet             0
pe                0
ane               0
classification    0
dtype: int64
****************************************************************************************************
age     0
bp      0
sg      0
al      0
su      0
bgr     0
bu      0
sc      0
sod     0
pot     0
hemo    0
dtype: int64

# bring the columns together with pd.concat
df_clean = pd.concat([numeric_columns_float32, df[cat_mask_object]], axis = 1)

# check the shape of the columns
df_clean.shape

(400, 22)

# just see the first 10 observations
df_clean.head(10)
# HTML(df_clean.to_html()) see the whole dataframe in HTML format

# now see the bottom 10
df_clean.tail(10)

HTML(df.to_html()) # just looking for something I may have missed in the pandas profiling

# some further cleaning is required to remove the \t characters is a couple of columns replacing the instances with the standard formating
# classification, cad,  dm
df_clean['classification'] = df_clean['classification'].replace("ckd\t","ckd")
df_clean['cad'] = df_clean['cad'].replace("\tno","no")
df_clean['dm'] = df_clean['dm'].replace("\tno","no")
df_clean['dm'] = df_clean['dm'].replace("\tyes", "yes")
df_clean['dm'] = df_clean['dm'].replace(" yes", "yes")

# subsetting columns with another boolean mask for categorical columns and object columns
cat_mask_obj2 = (df_clean.dtypes == "object") | (df_clean.dtypes == "category")

# Get list of categorical column names
cat_mask_object2 = df_clean.columns[cat_mask_obj2].tolist()

# remove the column classification
cat_mask_object2.remove("classification")

# see what columns are left
print(cat_mask_object2)

['rbc', 'pc', 'pcc', 'ba', 'htn', 'dm', 'cad', 'appet', 'pe', 'ane']

# look into the XGBoost course to figure out how the categorical imputer works
# combine everything and use DictVectorizer for one hot encoding and label encoding

# conversion of our dataframe into a dictionary so as to use DictVectorizer
# this function is mostly used in text processing
df_dict = df_clean[cat_mask_object2].to_dict("records")

# Make a DictVectorizer: use documentation to learn how it works
# In short, it speeds up one hot encoding with meaningful columns created
# we don't want a sparse matrix right?
dv = DictVectorizer(sparse = False)

# Apply fit_transform to our dataset
df_encoded = dv.fit_transform(df_dict)

# see 10 rows
print (df_encoded[:10,:])
print ("=" * 100) # just formatting to distinguish outputs

# print the vocabulary that is, the columns of the dataset, note that order changes
# upon transformation
print(dv.vocabulary_)
print ("=" * 100) # more formatting

print(df_encoded.shape) # number of rows and columns for the encoded dataset
print(df_clean[cat_mask_object2].shape) # number of rows and columns for the original dataset
print("After doing the transformation the columns increase to 21.")

[[0. 1. 0. 1. 0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0. 0. 1. 0. 0. 1. 0. 1. 0.
  0. 1. 0. 0. 1. 0.]
 [0. 1. 0. 1. 0. 0. 0. 1. 0. 0. 1. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0.
  0. 1. 0. 0. 1. 0.]
 [0. 0. 1. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 0. 0. 1. 0. 1. 0.
  0. 1. 0. 0. 0. 1.]
 [0. 0. 1. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 1. 0. 0. 0. 0. 1.
  0. 0. 1. 0. 0. 1.]
 [0. 1. 0. 1. 0. 0. 0. 1. 0. 0. 1. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0.
  0. 1. 0. 0. 0. 1.]
 [0. 1. 0. 1. 0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0. 0. 1. 0. 1. 0. 0. 1. 0.
  0. 0. 1. 0. 1. 0.]
 [0. 1. 0. 1. 0. 0. 0. 1. 0. 0. 1. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0.
  0. 1. 0. 0. 1. 0.]
 [0. 1. 0. 1. 0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0. 1. 0. 1. 0. 0. 0. 1. 0.
  0. 0. 1. 0. 0. 1.]
 [0. 0. 1. 1. 0. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0. 0. 1. 1. 0. 0. 0. 0. 1.
  0. 1. 0. 0. 0. 1.]
 [0. 0. 1. 0. 0. 1. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0. 0. 1. 1. 0. 0. 0. 0. 1.
  0. 1. 0. 1. 0. 0.]]
====================================================================================================
{'rbc=miss': 28, 'pc=normal': 20, 'pcc=notpresent': 22, 'ba=notpresent': 7, 'htn=yes': 17, 'dm=yes': 14, 'cad=no': 10, 'appet=good': 3, 'pe=no': 25, 'ane=no': 1, 'htn=no': 16, 'dm=no': 13, 'rbc=normal': 29, 'appet=poor': 5, 'ane=yes': 2, 'pc=abnormal': 18, 'pcc=present': 23, 'pe=yes': 26, 'pc=miss': 19, 'rbc=abnormal': 27, 'cad=yes': 11, 'ba=present': 8, 'htn=miss': 15, 'dm=miss': 12, 'cad=miss': 9, 'pcc=miss': 21, 'ba=miss': 6, 'appet=miss': 4, 'pe=miss': 24, 'ane=miss': 0}
====================================================================================================
(400, 30)
(400, 10)
After doing the transformation the columns increase to 21.

# You can try
# make a pipeline to merge the encoding as well as the visualization
# Use t-SNE and or PCA to see the differences between groups this will be the EDA step
# make a train and test split go through the slides for how to win kaggle competitions and test the ideas
# make the next step a pipeline object like in the xgboost course and try random forest, xgboost and decision tree classifier
# later use the ensembling techniques: Try all the ensembling techniques you know.

# see the transformed dataframe with all the missing values imputed
df_clean[cat_mask_numeric]

# simply taking the vectorized columns and the numeric columns and bringing them together
# to make an array for a classifier
concat_cols = np.hstack((df_encoded, df_clean[cat_mask_numeric].values))

# another version that is in dataframe format
# make a dataframe with the encoded features and give the columns names from the dictVectorizer
df_cat_var = pd.DataFrame(df_encoded, columns=dv.get_feature_names_out())

# combine the columns together with the categorical features i.e add columns to the numerical dataframe with other dataframe with the categorical and object data types
concat_cols_df = pd.concat([df_clean[cat_mask_numeric], df_cat_var], axis=1)
concat_cols.shape

(400, 41)

# the final dataframe we'll use for classification
concat_cols_df

# this operation is not necessary but it's good to see the final dataframe
#pd.set_option('future.no_silent_downcasting', True)

# now get the target variable into a numeric form
# there's a simpler step where you can use map instead  y = df_clean["classification"].map(lambda val1: 1 if val1 == "ckd" else 0)
# y = y.values
col_preprocess = df_clean["classification"].replace("ckd", 1)
final_col_preprocess = col_preprocess.replace("notckd", 0)
y = final_col_preprocess.values
print(y)

[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]

/tmp/ipykernel_814016/899742435.py:5: FutureWarning: Downcasting behavior in `replace` is deprecated and will be removed in a future version. To retain the old behavior, explicitly call `result.infer_objects(copy=False)`. To opt-in to the future behavior, set `pd.set_option('future.no_silent_downcasting', True)`
  final_col_preprocess = col_preprocess.replace("notckd", 0)

# confirm if the shape of the vector and matrix
print(concat_cols.shape)
print(y.shape)

(400, 41)
(400,)

# now that we have both matrices we can see the distribution of the target variable to know what to do next
# when it comes to preprocessing
final_col_preprocess.reset_index()["classification"].value_counts(normalize=True)

classification
1    0.625
0    0.375
Name: proportion, dtype: float64

# 3 split to evaluate model performance: do this to evaluate models better
features_train, features_validation_test, labels_train, labels_validation_test = train_test_split(concat_cols_df, y, test_size=0.4, random_state=100)
features_validation, features_test, labels_validation, labels_test = train_test_split( features_validation_test, labels_validation_test, test_size=0.5, random_state=100)

# The patients with chronic kidney disease are more than those who don't have .63 ckd and .38 for nonckd
# The dataset is imbalanced, we can't use the regular accuracy as an evaluation metric instead confusion matrix and F1 score
# we don't want more of the train set in either so I guess stratify is good option
# I changed the 0.5:0.5 to 0.75:0.25
x_train, x_test, y_train, y_test = train_test_split(concat_cols_df, y, test_size = 0.25, stratify = y, random_state=1243)

# Check if the dimensionality is the same for the feature and target set (train)
print("Is the number of rows the same between the features and the target?")
assert x_train.shape[0] == y_train.shape[0]
print (True)

Is the number of rows the same between the features and the target?
True

# Check if the dimensionality is the same for the feature and target set (test)
print("Is the number of rows the same between the features and the target?")
assert x_test.shape[0] == y_test.shape[0]
print (True)

Is the number of rows the same between the features and the target?
True

# Now checking if the target variable is balanced in the train set
pd.Series(y_train).value_counts(normalize=True)

1    0.623333
0    0.376667
Name: proportion, dtype: float64

# They are still unbalanced now. Therefore, will have to use the f1 score and change the class weight of the algorithms used like logistic regression

# look at the instances of the labels 0 and 1
pd.Series(y_test).value_counts(normalize=True)

1    0.63
0    0.37
Name: proportion, dtype: float64

# convert all the target variables to integers
y_train = y_train.astype(int)
y_test = y_test.astype(int)

# normal scikit learn paradigm of specify, fit and predict for logistic regression or continuos perceptron
clf_lr1 = LogisticRegression(class_weight="balanced", random_state=1243, max_iter=1000)

clf_lr1.fit(x_train,y_train)

preds1 = clf_lr1.predict(x_test)

# using f1 score instead of other metrics
score_vote1 = f1_score(preds1, y_test)
print('F1-Score: {:.3f}'.format(score_vote1))

# Calculate the classification report
report1 = classification_report(y_test, preds1,target_names=["notckd", "ckd"])
print(report1)

F1-Score: 0.992
              precision    recall  f1-score   support

      notckd       0.97      1.00      0.99        37
         ckd       1.00      0.98      0.99        63

    accuracy                           0.99       100
   macro avg       0.99      0.99      0.99       100
weighted avg       0.99      0.99      0.99       100

# Specify the Decision tree classifier: asks a bunch of if-else statements to come up with a decision
# adjust the number of min samples leaf based on the game 20 questions (From deep learning for coders by Jeremy Howard)
clf_dt2 = DecisionTreeClassifier(class_weight = "balanced",random_state=1243)

clf_dt2.fit(x_train,y_train)

preds2 = clf_dt2.predict(x_test)

score_vote2 = f1_score(preds2, y_test)
print('F1-Score: {:.3f}'.format(score_vote2))

# Calculate the classification report
report2 = classification_report(y_test, preds2, target_names=["notckd", "ckd"])
print(report2)

F1-Score: 0.959
              precision    recall  f1-score   support

      notckd       0.88      1.00      0.94        37
         ckd       1.00      0.92      0.96        63

    accuracy                           0.95       100
   macro avg       0.94      0.96      0.95       100
weighted avg       0.96      0.95      0.95       100

# check the parameters of the decision tree classifier in new lines to see what you can change
clf_dt2.get_params().keys()

dict_keys(['ccp_alpha', 'class_weight', 'criterion', 'max_depth', 'max_features', 'max_leaf_nodes', 'min_impurity_decrease', 'min_samples_leaf', 'min_samples_split', 'min_weight_fraction_leaf', 'monotonic_cst', 'random_state', 'splitter'])

# normalize data functions
# log, z scores(standardized_data), dimensionality reduction with PCA(dim_reduction) and making a function that combines another function(compose2)
def skew (data):
    skewed_data = np.log(data)
    return skewed_data


def standardized_data(data):
    scaler = StandardScaler()
    scaler.fit(data)
    scaled_data = scaler.transform(data)
    return scaled_data

def dim_reduction(data):
    pca = PCA(n_components=2)
    return pca.fit_transform(data)


def compose2(f, g):
    return lambda *a, **kw: f(g(*a, **kw))

def compose(*fs):
    return reduce(compose2, fs)


# returns an error due to the points being too small
normalize_data = compose2(skew, standardized_data)

# mean of 0 and a std 1 for all the columns
scaled_x_train = standardized_data(x_train)
scaled_x_test = standardized_data(x_test)

# add for the smaller datasets
scaled_features_validation = standardized_data(features_validation)
scaled_features_test = standardized_data(features_test)

# reduce dimensionality to 2
transform_data = compose2(standardized_data, dim_reduction)
dim_red_x_train = transform_data(x_train)
dim_red_x_test = transform_data(x_test)

# Logistic regression just a modified perceptron algorithm that uses the sigmoid function therefore an continous perceptron
clf_lr3 = LogisticRegression(class_weight="balanced",random_state=1243)

clf_lr3.fit(scaled_x_train,y_train)

preds3 = clf_lr3.predict(scaled_x_test)

score_vote3 = f1_score(preds3, y_test)
print('F1-Score: {:.3f}'.format(score_vote3))

# Calculate the classification report
report3= classification_report(y_test, preds3,target_names=["notckd", "ckd"])
print(report3)

F1-Score: 0.976
              precision    recall  f1-score   support

      notckd       0.93      1.00      0.96        37
         ckd       1.00      0.95      0.98        63

    accuracy                           0.97       100
   macro avg       0.96      0.98      0.97       100
weighted avg       0.97      0.97      0.97       100

# Logistic regression but the features have been compressed
clf_lr5 = LogisticRegression(class_weight="balanced",random_state=1243)

clf_lr5.fit(dim_red_x_train,y_train)

preds5 = clf_lr5.predict(dim_red_x_test)

score_vote5 = f1_score(preds5, y_test)
print('F1-Score: {:.3f}'.format(score_vote5))

# Make a classification report
report5 = classification_report(y_test, preds5,target_names=["notckd", "ckd"])
print(report5)

F1-Score: 0.603
              precision    recall  f1-score   support

      notckd       0.40      0.51      0.45        37
         ckd       0.66      0.56      0.60        63

    accuracy                           0.54       100
   macro avg       0.53      0.53      0.53       100
weighted avg       0.57      0.54      0.55       100

# Decision tree classifier but with scaled features
clf_dt4 = DecisionTreeClassifier(class_weight="balanced", random_state=1243, min_samples_leaf=25)

clf_dt4.fit(scaled_x_train,y_train)

preds4 = clf_dt4.predict(scaled_x_test)

score_vote4 = f1_score(preds4, y_test)
print('F1-Score: {:.3f}'.format(score_vote4))

# Make a classification report
report4 = classification_report(y_test, preds4, target_names=["notckd", "ckd"],)
print(report4)

F1-Score: 0.879
              precision    recall  f1-score   support

      notckd       0.74      0.95      0.83        37
         ckd       0.96      0.81      0.88        63

    accuracy                           0.86       100
   macro avg       0.85      0.88      0.86       100
weighted avg       0.88      0.86      0.86       100

# take the coefficient and see the dimension
clf_lr1.coef_.shape

(1, 41)

# helps with visualizing the decision function for the classifier
def plot_points(features, labels):
    '''

    '''
    X = np.array(features) # convert data into an numpy array: features
    y = np.array(labels) # convert data into an numpy array: labels
    ckd = X[np.argwhere(y==1)] # get all instances where the features are for individuals with ckd
    notckd = X[np.argwhere(y==0)] # get all instances where the features are for individuals without ckd
    plt.scatter([s[0][0] for s in ckd],
                [s[0][1] for s in ckd],
                s = 30,
                color = 'cyan',
                edgecolor = 'k',
                marker = '^')
    plt.scatter([s[0][0] for s in notckd],
                [s[0][1] for s in notckd],
                s = 30,
                color = 'red',
                edgecolor = 'k',
                marker = 's')
    plt.xlabel('aack')
    plt.ylabel('beep')
    plt.legend(['ckd','notckd'])
def draw_line(a,b,c, color='black', linewidth=2.0, linestyle='solid', starting=0, ending=3):
    # Plotting the line ax + by + c = 0
    x = np.linspace(starting, ending, 1000)
    plt.plot(x, -c/b - a*x/b, linestyle=linestyle, color=color, linewidth=linewidth)

# Trying to visualize the function but this didn't work so well
X = np.array(concat_cols)
y = np.array(y)
ckd = X[np.argwhere(y==0)]
notckd = X[np.argwhere(y==1)]

plt.scatter([s[0][0] for s in ckd],
                [s[0][1] for s in ckd],
                s = 25,
                color = 'cyan',
                edgecolor = 'k',
                marker = '^')
plt.scatter([s[0][0] for s in notckd],
                [s[0][1] for s in notckd],
                s = 25,
                color = 'red',
                edgecolor = 'k',
                marker = 's')
plt.xlabel('ckd')
plt.ylabel('notckd')
plt.legend(['ckd','notckd'])

<matplotlib.legend.Legend at 0x7576f7874430>

# This needs some fixing: Please ignore this for now.
plot_points(scaled_x_train, y_train)
draw_line(1,1, clf_lr1.fit_intercept)

# Check this out https://github.com/luisguiserrano/manning/blob/master/Chapter%205%20-%20Logistic%20Regression/Coding%20the%20Logistic%20Regression%20Algorithm.ipynb

%matplotlib inline

# plotting feature importance for the Decision tree
# grab the column names as a list

features = concat_cols_df.columns

# get the feature importances
important_features = clf_dt2.feature_importances_

# find the indices of a sorted array
feature_indices = np.argsort(important_features)

# make a plot
plt.title('Feature Importances Decision Tree')
plt.xticks(fontsize=6, rotation = 45)
plt.barh(range(len(feature_indices)), important_features[feature_indices], color='g', align='center')
plt.yticks(range(len(feature_indices)), [features[i] for i in feature_indices], fontsize = 6)
plt.xlabel('Relative Importance')
plt.show()

# Reviewing feature importance using the logistic regression and the C parameter
# grab the coefficients and transpose the array
# label the C parameter
plt.plot(np.sort(clf_lr1.coef_.T), 'o', label="C=1",color = "g")
plt.xticks(range(concat_cols_df.shape[1]), concat_cols_df.columns, rotation=90)
plt.hlines(0, 0, concat_cols_df.shape[1])
plt.title("Examination of feature importance")
plt.xlabel("Coefficient index")
plt.ylabel("Coefficient magnitude")
plt.legend()

<matplotlib.legend.Legend at 0x73368de40610>

# Draw a feature importance plot for the logistic regression in the same way
plt.title('Feature Importances Logistic Regression')
plt.xticks(fontsize=6, rotation = 45)
plt.barh(range(len(feature_indices)), clf_lr1.coef_[0][feature_indices], color='g', align='center')
plt.yticks(range(len(feature_indices)), [features[i] for i in feature_indices], fontsize = 6)
plt.xlabel('Relative Importance')
plt.show()

#!pip install pydotplus -q

# draw the decision tree
# add more comments for this
import six
from IPython.display import Image
from sklearn.tree import export_graphviz
import pydotplus

dot_data = six.StringIO()
export_graphviz(clf_dt2, out_file=dot_data,
                filled=True, rounded=True,
                special_characters=True, feature_names = concat_cols_df.columns, class_names =["notckd", "ckd"])
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
Image(graph.create_png())

# look at hemo(hemoglobin), sg(specific gravity), al(albumin), sod(sodium), rbc=normal(red blood cells), htn=yes(hypertension), bu(blood urea)
# dm (diabetes mellitus)

from sklearn.tree import export_text

rules = export_text(clf_dt2, feature_names=list(concat_cols_df.columns))

print(rules)

|--- hemo <= 12.85
|   |--- sod <= 143.50
|   |   |--- sg <= 1.02
|   |   |   |--- class: 1
|   |   |--- sg >  1.02
|   |   |   |--- hemo <= 2.90
|   |   |   |   |--- rbc=normal <= 0.50
|   |   |   |   |   |--- pcc=present <= 0.50
|   |   |   |   |   |   |--- class: 1
|   |   |   |   |   |--- pcc=present >  0.50
|   |   |   |   |   |   |--- class: 1
|   |   |   |   |--- rbc=normal >  0.50
|   |   |   |   |   |--- class: 0
|   |   |   |--- hemo >  2.90
|   |   |   |   |--- class: 1
|   |--- sod >  143.50
|   |   |--- age <= 43.00
|   |   |   |--- class: 0
|   |   |--- age >  43.00
|   |   |   |--- pot <= 4.35
|   |   |   |   |--- class: 1
|   |   |   |--- pot >  4.35
|   |   |   |   |--- class: 1
|--- hemo >  12.85
|   |--- sg <= 1.02
|   |   |--- sg <= 0.50
|   |   |   |--- htn=yes <= 0.50
|   |   |   |   |--- class: 0
|   |   |   |--- htn=yes >  0.50
|   |   |   |   |--- class: 1
|   |   |--- sg >  0.50
|   |   |   |--- class: 1
|   |--- sg >  1.02
|   |   |--- dm=yes <= 0.50
|   |   |   |--- class: 0
|   |   |--- dm=yes >  0.50
|   |   |   |--- class: 1

# pertubation test
# this is a test to see how robust the model is
from sklearn.inspection import permutation_importance

# this is a test to see how robust the model is
result = permutation_importance(clf_dt2, x_test, y_test, n_repeats=10, random_state=1243)

sorted_idx = result.importances_mean.argsort()
plt.barh(range(len(sorted_idx)), result.importances_mean[sorted_idx], color='g', align='center')
plt.yticks(range(len(sorted_idx)), [features[i] for i in sorted_idx], fontsize = 6)
plt.xlabel('Relative Importance')
plt.title('Permutation Importances Decision Tree')

Text(0.5, 1.0, 'Permutation Importances Decision Tree')

# using shap values to compare the feature importance
# if they are stable

import shap
from sklearn.metrics.pairwise import cosine_similarity

# calculate shap values for logistic regression
# Wrap the model's predict_proba method in a callable function
def model_predict_proba(X):
	return clf_lr1.predict_proba(X)

# Create the SHAP explainer using the callable function
explainer = shap.Explainer(model_predict_proba, x_train)
shap_values = explainer(x_train)

# summarize the effects of all the features (reduce to 2D by averaging over the class dimension)
feature_imp_mod1 = np.mean(np.abs(shap_values.values).sum(axis=1), axis=0)


# calculate shap values for decision tree
explainer2 = shap.Explainer(clf_dt2)
shap_values2 = explainer2.shap_values(x_train)
# summarize the effects of all the features (reduce to 2D by averaging over the class dimension)
feature_imp_mod2 = np.mean(np.abs(shap_values2).sum(axis=1), axis=0)

# consistency calculation
consistency = cosine_similarity([feature_imp_mod1], [feature_imp_mod2])

print("The consistency of the two models is: ", consistency)

The consistency of the two models is:  [[1.]]

# Calculating model faitfulness by changing features and seeing if predictions change
try_pred = clf_dt2.predict(x_test)

# check the predictions
print("Original predictions: ", try_pred)

# changing the features on hemo comparing versus original
# ranges between 3.1 to 17.8 decisively 12.85
x_test2 = x_test.copy()

x_test2.iloc[:, 0] = 12.85
# check the predictions
preds2 = clf_dt2.predict(x_test2)

# compare the predictions with the actual y_test values
# Calculate cosine similarity between original predictions and actual y_test
similarity_original = cosine_similarity([try_pred], [y_test])

# Calculate cosine similarity between modified predictions and actual y_test
similarity_modified = cosine_similarity([preds2], [y_test])

print("Cosine similarity (original predictions vs actual): ", similarity_original[0][0])
print("Cosine similarity (modified predictions vs actual): ", similarity_modified[0][0])

Original predictions:  [1 0 1 0 1 1 1 1 1 1 0 1 1 0 1 1 1 1 0 0 1 1 1 1 0 0 1 1 0 0 1 0 0 0 0 1 1
 0 1 0 1 0 1 0 1 1 1 1 1 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 0 0 1 1 1
 1 0 1 1 1 0 1 0 1 0 0 0 1 0 0 0 1 1 0 1 1 1 1 1 1 0]
Cosine similarity (original predictions vs actual):  0.9594972228385658
Cosine similarity (modified predictions vs actual):  0.9428090415820634

/tmp/ipykernel_814016/3853791278.py:11: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise in a future error of pandas. Value '12.85' has dtype incompatible with float32, please explicitly cast to a compatible dtype first.
  x_test2.iloc[:, 0] = 12.85

# interpreting the logistic regression model
clf_lr1.predict(x_test[:1])

array([1])

# checking out the intercept this means that if every feature is 0 what the prediction would be
clf_lr1.intercept_

array([5.76320108])

# checking out the coefficients we'll multiply this by the every value that corresponds to that feature e.g clf_lr1.coef[0] * age[0]
clf_lr1.coef_

array([[ 0.0063346 , -0.01842495,  0.22342211,  1.32314306,  0.32025324,
         0.01268437, -0.00690186,  1.32353171, -0.02486324, -0.20097746,
        -0.23277008, -0.0221892 , -0.16596807,  0.19124526, -0.26965719,
        -0.0221892 ,  0.29493439, -0.01686371, -0.13511728,  0.15506898,
        -0.02987156, -0.06799412,  0.10095367, -0.02987156, -0.88891432,
         0.92187387, -0.02987156, -0.62832756,  0.66128711,  0.55442474,
        -0.44919695, -0.1021398 , -0.01686371,  0.00382733,  0.01612436,
        -0.0221892 , -0.38755198,  0.41282917,  0.08652115,  1.7289188 ,
        -1.81235197]])

# checking out the available columns
concat_cols_df.columns

Index(['age', 'bp', 'sg', 'al', 'su', 'bgr', 'bu', 'sc', 'sod', 'pot', 'hemo',
       'ane=miss', 'ane=no', 'ane=yes', 'appet=good', 'appet=miss',
       'appet=poor', 'ba=miss', 'ba=notpresent', 'ba=present', 'cad=miss',
       'cad=no', 'cad=yes', 'dm=miss', 'dm=no', 'dm=yes', 'htn=miss', 'htn=no',
       'htn=yes', 'pc=abnormal', 'pc=miss', 'pc=normal', 'pcc=miss',
       'pcc=notpresent', 'pcc=present', 'pe=miss', 'pe=no', 'pe=yes',
       'rbc=abnormal', 'rbc=miss', 'rbc=normal'],
      dtype='object')

# make a dataframe to help easily grab the coefficients for writing the formula and visualizing the data
# transpose to see it clearly
important_features2 = clf_lr1.coef_[0]
column_coef = pd.DataFrame(list(zip(important_features2.T.ravel("C").tolist(), features)),columns = ["coefficient", "feature"])
column_coef["coefficient"] = column_coef["coefficient"].astype("float32")
column_coef.T

# arrange the coeffiecients in descending order to know the most likely features
column_coef.sort_values(by=["coefficient"], axis = 0, inplace=True, ascending=False)
print(column_coef.head(10))

    coefficient      feature
39     1.728919     rbc=miss
7      1.323532           sc
3      1.323143           al
25     0.921874       dm=yes
28     0.661287      htn=yes
29     0.554425  pc=abnormal
37     0.412829       pe=yes
4      0.320253           su
16     0.294934   appet=poor
2      0.223422           sg

x_test[:1] # see all the features in the first column

x_test.shape # see the number of rows and columns

(100, 41)

# writing the logistic regression formula
# Bo intercept, B1 x1n
# writing the denominator based on the wikipedia entry https://en.wikipedia.org/wiki/Logistic_regression
# 1/ np.exp(-(weight * coefn + clf_lr1.intercept_))
weights_int_bias = clf_lr1.intercept_ + (column_coef.coefficient[0] * 60.0) + (column_coef.coefficient[1] * 60.0) + (column_coef.coefficient[2] * 1.01) + (column_coef.coefficient[3] + 3.0) + (column_coef.coefficient[4] + 1.0) + (column_coef.coefficient[5] * 288) + (column_coef.coefficient[6] * 36.0) + (column_coef.coefficient[7] * 1.7) + (column_coef.coefficient[8] * 130) + (column_coef.coefficient[9] * 3.0) + (column_coef.coefficient[10] * 7.9) + (column_coef.coefficient[11] * 0.0) + (column_coef.coefficient[12] * 0.0) + (column_coef.coefficient[13] * 1.0) + (column_coef.coefficient[14] * 0.0) + (column_coef.coefficient[15] * 0.0) + (column_coef.coefficient[16] * 1.0) + (column_coef.coefficient[17] * 0.0) + (column_coef.coefficient[18] * 1.0) + (column_coef.coefficient[19] * 0.0) + (column_coef.coefficient[20] * 0.0) + (column_coef.coefficient[21] * 1.0) + (column_coef.coefficient[22] * 0.0) + (column_coef.coefficient[23] * 0.0) + (column_coef.coefficient[24] * 1.0) + (column_coef.coefficient[25] * 0.0) +  (column_coef.coefficient[26] * 0.0) + (column_coef.coefficient[27] * 1.0) + (column_coef.coefficient[28] * 1.0) + (column_coef.coefficient[29] * 0.0) + (column_coef.coefficient[30] * 0.0) + (column_coef.coefficient[31] * 0.0) + (column_coef.coefficient[32] * 0.0) + (column_coef.coefficient[33] * 1.0) + (column_coef.coefficient[34] * 0.0) + (column_coef.coefficient[35] * 0.0) + (column_coef.coefficient[36] * 0.0) + (column_coef.coefficient[37] * 0.0) + (column_coef.coefficient[38] * 0.0) + (column_coef.coefficient[39] * 1.0)

# add the sigmoid function to make the decision
# One way to make the loss function
def sigmoid(x):
    return np.exp(x)/(1+np.exp(x))


print(sigmoid(weights_int_bias))

[0.99999414]

# according to wikipedia implementation: sigmoid function
1 / (1 + np.exp(-weights_int_bias))

array([0.99999414])

clf_lr1.predict(x_test[:1]) # has chronic kidney disease for the 147th id

array([1])

	age	bp	sg	al	su	bgr	bu	sc	sod	pot	hemo
id
0	48.0	80.0	1.020	1.0	0.0	121.0	36.0	1.2	0.0	0.0	15.4
1	7.0	50.0	1.020	4.0	0.0	0.0	18.0	0.8	0.0	0.0	11.3
2	62.0	80.0	1.010	2.0	3.0	423.0	53.0	1.8	0.0	0.0	9.6
3	48.0	70.0	1.005	4.0	0.0	117.0	56.0	3.8	111.0	2.5	11.2
4	51.0	80.0	1.010	2.0	0.0	106.0	26.0	1.4	0.0	0.0	11.6
...	...	...	...	...	...	...	...	...	...	...	...
395	55.0	80.0	1.020	0.0	0.0	140.0	49.0	0.5	150.0	4.9	15.7
396	42.0	70.0	1.025	0.0	0.0	75.0	31.0	1.2	141.0	3.5	16.5
397	12.0	80.0	1.020	0.0	0.0	100.0	26.0	0.6	137.0	4.4	15.8
398	17.0	60.0	1.025	0.0	0.0	114.0	50.0	1.0	135.0	4.9	14.2
399	58.0	80.0	1.025	0.0	0.0	131.0	18.0	1.1	141.0	3.5	15.8

Introduction¶

Loading data and Exploratory data analysis¶

Split the dataframe to 3 for more training and compare result with the same configuration set¶

To do: Tests for overfitting¶

Conclusion:¶

	count	unique	top	freq	mean	std	min	25%	50%	75%	max
age	391.0	NaN	NaN	NaN	51.483376	17.169714	2.0	42.0	55.0	64.5	90.0
bp	388.0	NaN	NaN	NaN	76.469072	13.683637	50.0	70.0	80.0	80.0	180.0
sg	353.0	NaN	NaN	NaN	1.017408	0.005717	1.005	1.01	1.02	1.02	1.025
al	354.0	NaN	NaN	NaN	1.016949	1.352679	0.0	0.0	0.0	2.0	5.0
su	351.0	NaN	NaN	NaN	0.450142	1.099191	0.0	0.0	0.0	0.0	5.0
rbc	248	2	normal	201	NaN	NaN	NaN	NaN	NaN	NaN	NaN
pc	335	2	normal	259	NaN	NaN	NaN	NaN	NaN	NaN	NaN
pcc	396	2	notpresent	354	NaN	NaN	NaN	NaN	NaN	NaN	NaN
ba	396	2	notpresent	374	NaN	NaN	NaN	NaN	NaN	NaN	NaN
bgr	356.0	NaN	NaN	NaN	148.036517	79.281714	22.0	99.0	121.0	163.0	490.0
bu	381.0	NaN	NaN	NaN	57.425722	50.503006	1.5	27.0	42.0	66.0	391.0
sc	383.0	NaN	NaN	NaN	3.072454	5.741126	0.4	0.9	1.3	2.8	76.0
sod	313.0	NaN	NaN	NaN	137.528754	10.408752	4.5	135.0	138.0	142.0	163.0
pot	312.0	NaN	NaN	NaN	4.627244	3.193904	2.5	3.8	4.4	4.9	47.0
hemo	348.0	NaN	NaN	NaN	12.526437	2.912587	3.1	10.3	12.65	15.0	17.8
pcv	330	44	41	21	NaN	NaN	NaN	NaN	NaN	NaN	NaN
wc	295	92	9800	11	NaN	NaN	NaN	NaN	NaN	NaN	NaN
rc	270	49	5.2	18	NaN	NaN	NaN	NaN	NaN	NaN	NaN
htn	398	2	no	251	NaN	NaN	NaN	NaN	NaN	NaN	NaN
dm	398	5	no	258	NaN	NaN	NaN	NaN	NaN	NaN	NaN
cad	398	3	no	362	NaN	NaN	NaN	NaN	NaN	NaN	NaN
appet	399	2	good	317	NaN	NaN	NaN	NaN	NaN	NaN	NaN
pe	399	2	no	323	NaN	NaN	NaN	NaN	NaN	NaN	NaN
ane	399	2	no	339	NaN	NaN	NaN	NaN	NaN	NaN	NaN
classification	400	3	ckd	248	NaN	NaN	NaN	NaN	NaN	NaN	NaN

	age	bp	sg	al	su	bgr	bu	sc	sod	pot	...	pc	pcc	ba	htn	dm	cad	appet	pe	ane	classification
id
390	52.0	80.0	1.025	0.0	0.0	99.0	25.0	0.8	135.0	3.7	...	normal	notpresent	notpresent	no	no	no	good	no	no	notckd
391	36.0	80.0	1.025	0.0	0.0	85.0	16.0	1.1	142.0	4.1	...	normal	notpresent	notpresent	no	no	no	good	no	no	notckd
392	57.0	80.0	1.020	0.0	0.0	133.0	48.0	1.2	147.0	4.3	...	normal	notpresent	notpresent	no	no	no	good	no	no	notckd
393	43.0	60.0	1.025	0.0	0.0	117.0	45.0	0.7	141.0	4.4	...	normal	notpresent	notpresent	no	no	no	good	no	no	notckd
394	50.0	80.0	1.020	0.0	0.0	137.0	46.0	0.8	139.0	5.0	...	normal	notpresent	notpresent	no	no	no	good	no	no	notckd
395	55.0	80.0	1.020	0.0	0.0	140.0	49.0	0.5	150.0	4.9	...	normal	notpresent	notpresent	no	no	no	good	no	no	notckd
396	42.0	70.0	1.025	0.0	0.0	75.0	31.0	1.2	141.0	3.5	...	normal	notpresent	notpresent	no	no	no	good	no	no	notckd
397	12.0	80.0	1.020	0.0	0.0	100.0	26.0	0.6	137.0	4.4	...	normal	notpresent	notpresent	no	no	no	good	no	no	notckd
398	17.0	60.0	1.025	0.0	0.0	114.0	50.0	1.0	135.0	4.9	...	normal	notpresent	notpresent	no	no	no	good	no	no	notckd
399	58.0	80.0	1.025	0.0	0.0	131.0	18.0	1.1	141.0	3.5	...	normal	notpresent	notpresent	no	no	no	good	no	no	notckd

	0	1	2	3	4	5	6	7	8	9	...	31	32	33	34	35	36	37	38	39	40
coefficient	0.006335	-0.018425	0.223422	1.323143	0.320253	0.012684	-0.006902	1.323532	-0.024863	-0.200977	...	-0.10214	-0.016864	0.003827	0.016124	-0.022189	-0.387552	0.412829	0.086521	1.728919	-1.812352
feature	age	bp	sg	al	su	bgr	bu	sc	sod	pot	...	pc=normal	pcc=miss	pcc=notpresent	pcc=present	pe=miss	pe=no	pe=yes	rbc=abnormal	rbc=miss	rbc=normal